// This needs to be global to avoid TS2403 in case lib.dom.d.ts is present in the same build

//@@{ 控制台_:Console }
接口 控制台_ {

    //@@{ 控制台_:Console, 控制台构造函数_:ConsoleConstructor }
    控制台_: NodeJS.控制台构造函数_;
    /**
     * A simple assertion test that verifies whether `value` is truthy.
     * If it is not, an `AssertionError` is thrown.
     * If provided, the error `message` is formatted using `util.format()` and used as the error message.
     */

    //@@{ 断言:assert }
    断言(值: 任意, 消息?: 文字, ...可选参数: 任意[]): 无值;
    /**
     * When `stdout` is a TTY, calling `console.clear()` will attempt to clear the TTY.
     * When `stdout` is not a TTY, this method does nothing.
     */

    //@@{ 清除:clear }
    清除(): 无值;
    /**
     * Maintains an internal counter specific to `label` and outputs to `stdout` the number of times `console.count()` has been called with the given `label`.
     */

    //@@{ 数量:count }
    数量(标签?: 文字): 无值;
    /**
     * Resets the internal counter specific to `label`.
     */

    //@@{ 计数复位:countReset }
    计数复位(标签?: 文字): 无值;
    /**
     * The `console.debug()` function is an alias for {@link console.log()}.
     */

    //@@{ 调试程序:debug }
    调试程序(消息?: 任意, ...可选参数: 任意[]): 无值;
    /**
     * Uses {@link util.inspect()} on `obj` and prints the resulting string to `stdout`.
     * This function bypasses any custom `inspect()` function defined on `obj`.
     */

    //@@{ 细节:dir, 检查选项_:InspectOptions }
    细节(对象: 任意, 选项组?: NodeJS.检查选项_): 无值;
    /**
     * This method calls {@link console.log()} passing it the arguments received. Please note that this method does not produce any XML formatting
     */

    //@@{ 细节xml:dirxml }
    细节xml(...数据: 任意[]): 无值;
    /**
     * Prints to `stderr` with newline.
     */

    //@@{ 错误:error }
    错误(消息?: 任意, ...可选参数: 任意[]): 无值;
    /**
     * Increases indentation of subsequent lines by two spaces.
     * If one or more `label`s are provided, those are printed first without the additional indentation.
     */

    //@@{ 集团:group }
    集团(...标签: 任意[]): 无值;
    /**
     * The `console.groupCollapsed()` function is an alias for {@link console.group()}.
     */

    //@@{ 集团塌陷:groupCollapsed }
    集团塌陷(...标签: 任意[]): 无值;
    /**
     * Decreases indentation of subsequent lines by two spaces.
     */

    //@@{ 集团结束:groupEnd }
    集团结束(): 无值;
    /**
     * The {@link console.info()} function is an alias for {@link console.log()}.
     */

    //@@{ 信息:info }
    信息(消息?: 任意, ...可选参数: 任意[]): 无值;
    /**
     * Prints to `stdout` with newline.
     */

    //@@{ 日志:log }
    日志(消息?: 任意, ...可选参数: 任意[]): 无值;
    /**
     * This method does not display anything unless used in the inspector.
     *  Prints to `stdout` the array `array` formatted as a table.
     */

    //@@{ 表:table }
    表(表格数据: 任意, 属性组?: 文字[]): 无值;
    /**
     * Starts a timer that can be used to compute the duration of an operation. Timers are identified by a unique `label`.
     */

    //@@{ 时间:time }
    时间(标签?: 文字): 无值;
    /**
     * Stops a timer that was previously started by calling {@link console.time()} and prints the result to `stdout`.
     */

    //@@{ 时间结束:timeEnd }
    时间结束(标签?: 文字): 无值;
    /**
     * For a timer that was previously started by calling {@link console.time()}, prints the elapsed time and other `data` arguments to `stdout`.
     */

    //@@{ 时间日志:timeLog }
    时间日志(标签?: 文字, ...数据: 任意[]): 无值;
    /**
     * Prints to `stderr` the string 'Trace :', followed by the {@link util.format()} formatted message and stack trace to the current position in the code.
     */

    //@@{ 跟踪:trace }
    跟踪(消息?: 任意, ...可选参数: 任意[]): 无值;
    /**
     * The {@link console.warn()} function is an alias for {@link console.error()}.
     */

    //@@{ 警告:warn }
    警告(消息?: 任意, ...可选参数: 任意[]): 无值;

    // --- Inspector mode only ---
    /**
     * This method does not display anything unless used in the inspector.
     *  The console.markTimeline() method is the deprecated form of console.timeStamp().
     *
     * @deprecated Use console.timeStamp() instead.
     */

    //@@{ mark时间表:markTimeline }
    mark时间表(标签?: 文字): 无值;
    /**
     * This method does not display anything unless used in the inspector.
     *  Starts a JavaScript CPU profile with an optional label.
     */

    //@@{ 概要文件:profile }
    概要文件(标签?: 文字): 无值;
    /**
     * This method does not display anything unless used in the inspector.
     *  Stops the current JavaScript CPU profiling session if one has been started and prints the report to the Profiles panel of the inspector.
     */

    //@@{ 概要文件结束:profileEnd }
    概要文件结束(标签?: 文字): 无值;
    /**
     * This method does not display anything unless used in the inspector.
     *  Adds an event with the label `label` to the Timeline panel of the inspector.
     */

    //@@{ 时间戳:timeStamp }
    时间戳(标签?: 文字): 无值;
    /**
     * This method does not display anything unless used in the inspector.
     *  The console.timeline() method is the deprecated form of console.time().
     *
     * @deprecated Use console.time() instead.
     */

    //@@{ 时间轴:timeline }
    时间轴(标签?: 文字): 无值;
    /**
     * This method does not display anything unless used in the inspector.
     *  The console.timelineEnd() method is the deprecated form of console.timeEnd().
     *
     * @deprecated Use console.timeEnd() instead.
     */

    //@@{ 时间轴结束:timelineEnd }
    时间轴结束(标签?: 文字): 无值;
}

//@@{ 错误_:Error }
接口 错误_ {

    //@@{ 堆栈:stack }
    堆栈?: 文字;
}

// Declare "static" methods in Error

//@@{ 错误构造函数_:ErrorConstructor }
接口 错误构造函数_ {
    /** Create .stack property on a target object */

    //@@{ 捕获堆栈跟踪:captureStackTrace, 实例_:Object, 函数_:Function }
    捕获堆栈跟踪(目标对象: 实例_, 构造函数选项?: 函数_): 无值;

    /**
     * Optional override for formatting stack traces
     *
     * @see https://github.com/v8/v8/wiki/Stack%20Trace%20API#customizing-stack-traces
     */

    //@@{ 准备堆栈跟踪:prepareStackTrace, 错误_:Error, 呼叫站点_:CallSite }
    准备堆栈跟踪?: (错: 错误_, 堆栈跟踪: NodeJS.呼叫站点_[]) => 任意;

    //@@{ 堆栈跟踪限制:stackTraceLimit }
    堆栈跟踪限制: 数字;
}

//@@{ 符号构造函数_:SymbolConstructor }
接口 符号构造函数_ {

    //@@{ 可观察的:observable }
    只读 可观察的: 符号;
}

// Node.js ESNEXT support

//@@{ 文字_:String }
接口 文字_ {
    /** Removes whitespace from the left end of a string. */

    //@@{ 修剪左:trimLeft }
    修剪左(): 文字;
    /** Removes whitespace from the right end of a string. */

    //@@{ 修剪右:trimRight }
    修剪右(): 文字;
}

/*-----------------------------------------------*
 *                                               *
 *                   GLOBAL                      *
 *                                               *
 ------------------------------------------------*/

//@@{ 进程:process, 进程_:Process }
声明 定义 进程: NodeJS.进程_;

//@@{ 全局:global, 全局_:Global }
声明 定义 全局: NodeJS.全局_;

//@@{ 控制台:console, 控制台_:Console }
声明 定义 控制台: 控制台_;

//@@{ __文件名:__filename }
声明 定义 __文件名: 文字;

//@@{ __目录名:__dirname }
声明 定义 __目录名: 文字;

//@@{ 设置超时:setTimeout, 超时_:Timeout }
声明 函数 设置超时(回调: (...参数组: 任意[]) => 无值, 毫秒: 数字, ...参数组: 任意[]): NodeJS.超时_;

//@@{ 设置超时:setTimeout }
声明 名域 设置超时 {

    //@@{ __转为预设__:__promisify__, 预设_:Promise }
    函数 __转为预设__(毫秒: 数字): 预设_<无值>;

    //@@{ __转为预设__:__promisify__, 预设_:Promise }
    函数 __转为预设__<T>(毫秒: 数字, 值: T): 预设_<T>;
}

//@@{ 清除超时:clearTimeout, 超时_:Timeout }
声明 函数 清除超时(超时Id: NodeJS.超时_): 无值;

//@@{ 设置时间间隔:setInterval, 超时_:Timeout }
声明 函数 设置时间间隔(回调: (...参数组: 任意[]) => 无值, 毫秒: 数字, ...参数组: 任意[]): NodeJS.超时_;

//@@{ 清除时间间隔:clearInterval, 超时_:Timeout }
声明 函数 清除时间间隔(间隔Id: NodeJS.超时_): 无值;

//@@{ 设置立即:setImmediate, 立即_:Immediate }
声明 函数 设置立即(回调: (...参数组: 任意[]) => 无值, ...参数组: 任意[]): NodeJS.立即_;

//@@{ 设置立即:setImmediate }
声明 名域 设置立即 {

    //@@{ __转为预设__:__promisify__, 预设_:Promise }
    函数 __转为预设__(): 预设_<无值>;

    //@@{ __转为预设__:__promisify__, 预设_:Promise }
    函数 __转为预设__<T>(值: T): 预设_<T>;
}

//@@{ 清除立即:clearImmediate, 立即_:Immediate }
声明 函数 清除立即(立即Id: NodeJS.立即_): 无值;

/**
 * @experimental
 */

//@@{ 队列微任务:queueMicrotask }
声明 函数 队列微任务(回调: () => 无值): 无值;

// TODO: change to `type NodeRequireFunction = (id: string) => any;` in next mayor version.

//@@{ Node需要函数_:NodeRequireFunction }
接口 Node需要函数_ {
    /* tslint:disable-next-line:callable-types */
    (id: 文字): 任意;
}

//@@{ Node需要_:NodeRequire, Node需要函数_:NodeRequireFunction }
接口 Node需要_ 扩展 Node需要函数_ {

    //@@{ 解决:resolve, 需求解析_:RequireResolve }
    解决: 需求解析_;

    //@@{ 缓存:cache }
    缓存: 任意;
    /**
     * @deprecated
     */

    //@@{ 扩展组:extensions, Node扩展_:NodeExtensions }
    扩展组: Node扩展_;

    //@@{ 主要:main, Node模块_:NodeModule }
    主要: Node模块_ | 未定;
}

//@@{ 需求解析_:RequireResolve }
接口 需求解析_ {

    //@@{ 路径组:paths }
    (id: 文字, 选项组?: { 路径组?: 文字[]; }): 文字;

    //@@{ 路径组:paths }
    路径组(请求: 文字): 文字[] | 空值;
}

//@@{ Node扩展_:NodeExtensions }
接口 Node扩展_ {

    //@@{ Node模块_:NodeModule }
    '.js': (m: Node模块_, 文件名称: 文字) => 任意;

    //@@{ Node模块_:NodeModule }
    '.json': (m: Node模块_, 文件名称: 文字) => 任意;

    //@@{ Node模块_:NodeModule }
    '.node': (m: Node模块_, 文件名称: 文字) => 任意;

    //@@{ Node模块_:NodeModule }
    [扩展名: 文字]: (m: Node模块_, 文件名称: 文字) => 任意;
}

//@@{ 需要:require, Node需要_:NodeRequire }
声明 定义 需要: Node需要_;

//@@{ Node模块_:NodeModule }
接口 Node模块_ {

    //@@{ 输出组:exports }
    输出组: 任意;

    //@@{ 需要:require, Node需要函数_:NodeRequireFunction }
    需要: Node需要函数_;
    id: 文字;

    //@@{ 文件名称:filename }
    文件名称: 文字;

    //@@{ 加载了:loaded }
    加载了: 真假;

    //@@{ 父:parent, Node模块_:NodeModule }
    父: Node模块_ | 空值;

    //@@{ 子属性:children, Node模块_:NodeModule }
    子属性: Node模块_[];

    //@@{ 路径组:paths }
    路径组: 文字[];
}

//@@{ 模块:module, Node模块_:NodeModule }
声明 定义 模块: Node模块_;

// Same as module.exports

//@@{ 输出组:exports }
声明 定义 输出组: 任意;

// Buffer class

//@@{ 缓冲区编码_:BufferEncoding }
类型 缓冲区编码_ = "ascii" | "utf8" | "utf-8" | "utf16le" | "ucs2" | "ucs-2" | "base64" | "latin1" | "binary" | "hex";

//@@{ 缓冲区_:Buffer, 正整数数组8_:Uint8Array }
接口 缓冲区_ 扩展 正整数数组8_ {

    //@@{ 构造:constructor, 缓冲区_:Buffer }
    构造: 类为 缓冲区_;

    //@@{ 写:write, 缓冲区编码_:BufferEncoding }
    写(文字: 文字, 编码?: 缓冲区编码_): 数字;

    //@@{ 写:write, 缓冲区编码_:BufferEncoding }
    写(文字: 文字, 偏移: 数字, 编码?: 缓冲区编码_): 数字;

    //@@{ 写:write, 缓冲区编码_:BufferEncoding }
    写(文字: 文字, 偏移: 数字, 长度: 数字, 编码?: 缓冲区编码_): 数字;

    //@@{ 转为文字:toString }
    转为文字(编码?: 文字, 开始?: 数字, 结束?: 数字): 文字;

    //@@{ 转为JSON:toJSON, 类型:type, "缓冲区_":"Buffer", 数据:data }
    转为JSON(): { 类型: "缓冲区_", 数据: 数字[] };

    //@@{ 等于:equals, 正整数数组8_:Uint8Array }
    等于(其他缓冲区: 正整数数组8_): 真假;

    //@@{ 比较:compare, 正整数数组8_:Uint8Array }
    比较(其他缓冲区: 正整数数组8_, 目标开始?: 数字, 目标结束?: 数字, 源开始?: 数字, 源结束?: 数字): 数字;

    //@@{ 复制:copy, 正整数数组8_:Uint8Array }
    复制(目标缓冲区: 正整数数组8_, 目标开始?: 数字, 源开始?: 数字, 源结束?: 数字): 数字;

    //@@{ 分切:slice, 缓冲区_:Buffer }
    分切(开始?: 数字, 结束?: 数字): 缓冲区_;

    //@@{ 子数组:subarray, 缓冲区_:Buffer }
    子数组(开始: 数字, 结束?: 数字): 缓冲区_;

    //@@{ 写正整数小端:writeUIntLE }
    写正整数小端(值: 数字, 偏移: 数字, 字节长度: 数字): 数字;

    //@@{ 写正整数大端:writeUIntBE }
    写正整数大端(值: 数字, 偏移: 数字, 字节长度: 数字): 数字;

    //@@{ 写整数小端:writeIntLE }
    写整数小端(值: 数字, 偏移: 数字, 字节长度: 数字): 数字;

    //@@{ 写整数大端:writeIntBE }
    写整数大端(值: 数字, 偏移: 数字, 字节长度: 数字): 数字;

    //@@{ 读正整数小端:readUIntLE }
    读正整数小端(偏移: 数字, 字节长度: 数字): 数字;

    //@@{ 读正整数大端:readUIntBE }
    读正整数大端(偏移: 数字, 字节长度: 数字): 数字;

    //@@{ 读整数小端:readIntLE }
    读整数小端(偏移: 数字, 字节长度: 数字): 数字;

    //@@{ 读整数大端:readIntBE }
    读整数大端(偏移: 数字, 字节长度: 数字): 数字;

    //@@{ 读正整数8:readUInt8 }
    读正整数8(偏移: 数字): 数字;

    //@@{ 读正整数16小端:readUInt16LE }
    读正整数16小端(偏移: 数字): 数字;

    //@@{ 读正整数16大端:readUInt16BE }
    读正整数16大端(偏移: 数字): 数字;

    //@@{ 读正整数32小端:readUInt32LE }
    读正整数32小端(偏移: 数字): 数字;

    //@@{ 读正整数32大端:readUInt32BE }
    读正整数32大端(偏移: 数字): 数字;

    //@@{ 读整数8:readInt8 }
    读整数8(偏移: 数字): 数字;

    //@@{ 读整数16小端:readInt16LE }
    读整数16小端(偏移: 数字): 数字;

    //@@{ 读整数16大端:readInt16BE }
    读整数16大端(偏移: 数字): 数字;

    //@@{ 读整数32小端:readInt32LE }
    读整数32小端(偏移: 数字): 数字;

    //@@{ 读整数32大端:readInt32BE }
    读整数32大端(偏移: 数字): 数字;

    //@@{ 读浮点小端:readFloatLE }
    读浮点小端(偏移: 数字): 数字;

    //@@{ 读浮点大端:readFloatBE }
    读浮点大端(偏移: 数字): 数字;

    //@@{ 读双精度小端:readDoubleLE }
    读双精度小端(偏移: 数字): 数字;

    //@@{ 读双精度大端:readDoubleBE }
    读双精度大端(偏移: 数字): 数字;

    //@@{ 翻转:reverse }
    翻转(): 本体;

    //@@{ 交换16:swap16, 缓冲区_:Buffer }
    交换16(): 缓冲区_;

    //@@{ 交换32:swap32, 缓冲区_:Buffer }
    交换32(): 缓冲区_;

    //@@{ 交换64:swap64, 缓冲区_:Buffer }
    交换64(): 缓冲区_;

    //@@{ 写正整数8:writeUInt8 }
    写正整数8(值: 数字, 偏移: 数字): 数字;

    //@@{ 写正整数16小端:writeUInt16LE }
    写正整数16小端(值: 数字, 偏移: 数字): 数字;

    //@@{ 写正整数16大端:writeUInt16BE }
    写正整数16大端(值: 数字, 偏移: 数字): 数字;

    //@@{ 写正整数32小端:writeUInt32LE }
    写正整数32小端(值: 数字, 偏移: 数字): 数字;

    //@@{ 写正整数32大端:writeUInt32BE }
    写正整数32大端(值: 数字, 偏移: 数字): 数字;

    //@@{ 写整数8:writeInt8 }
    写整数8(值: 数字, 偏移: 数字): 数字;

    //@@{ 写整数16小端:writeInt16LE }
    写整数16小端(值: 数字, 偏移: 数字): 数字;

    //@@{ 写整数16大端:writeInt16BE }
    写整数16大端(值: 数字, 偏移: 数字): 数字;

    //@@{ 写整数32小端:writeInt32LE }
    写整数32小端(值: 数字, 偏移: 数字): 数字;

    //@@{ 写整数32大端:writeInt32BE }
    写整数32大端(值: 数字, 偏移: 数字): 数字;

    //@@{ 写浮点小端:writeFloatLE }
    写浮点小端(值: 数字, 偏移: 数字): 数字;

    //@@{ 写浮点大端:writeFloatBE }
    写浮点大端(值: 数字, 偏移: 数字): 数字;

    //@@{ 写双精度小端:writeDoubleLE }
    写双精度小端(值: 数字, 偏移: 数字): 数字;

    //@@{ 写双精度大端:writeDoubleBE }
    写双精度大端(值: 数字, 偏移: 数字): 数字;

    //@@{ 填充:fill }
    填充(值: 任意, 偏移?: 数字, 结束?: 数字): 本体;

    //@@{ 索引位于:indexOf, 正整数数组8_:Uint8Array, 缓冲区编码_:BufferEncoding }
    索引位于(值: 文字 | 数字 | 正整数数组8_, 字节偏移?: 数字, 编码?: 缓冲区编码_): 数字;

    //@@{ 最后索引位于:lastIndexOf, 正整数数组8_:Uint8Array, 缓冲区编码_:BufferEncoding }
    最后索引位于(值: 文字 | 数字 | 正整数数组8_, 字节偏移?: 数字, 编码?: 缓冲区编码_): 数字;

    //@@{ 条目:entries, 可迭代迭代器_:IterableIterator }
    条目(): 可迭代迭代器_<[数字, 数字]>;

    //@@{ 包括:includes, 缓冲区_:Buffer, 缓冲区编码_:BufferEncoding }
    包括(值: 文字 | 数字 | 缓冲区_, 字节偏移?: 数字, 编码?: 缓冲区编码_): 真假;

    //@@{ 键组:keys, 可迭代迭代器_:IterableIterator }
    键组(): 可迭代迭代器_<数字>;

    //@@{ 值组:values, 可迭代迭代器_:IterableIterator }
    值组(): 可迭代迭代器_<数字>;
}

/**
 * Raw data is stored in instances of the Buffer class.
 * A Buffer is similar to an array of integers but corresponds to a raw memory allocation outside the V8 heap.  A Buffer cannot be resized.
 * Valid string encodings: 'ascii'|'utf8'|'utf16le'|'ucs2'(alias of 'utf16le')|'base64'|'binary'(deprecated)|'hex'
 */

//@@{ 缓冲区_:Buffer }
声明 常量 缓冲区_: {
    /**
     * Allocates a new buffer containing the given {str}.
     *
     * @param str String to store in buffer.
     * @param encoding encoding to use, optional.  Default is 'utf8'
     * @deprecated since v10.0.0 - Use `Buffer.from(string[, encoding])` instead.
     */

    //@@{ 缓冲区编码_:BufferEncoding, 缓冲区_:Buffer }
    新建(字符串: 文字, 编码?: 缓冲区编码_): 缓冲区_;
    /**
     * Allocates a new buffer of {size} octets.
     *
     * @param size count of octets to allocate.
     * @deprecated since v10.0.0 - Use `Buffer.alloc()` instead (also see `Buffer.allocUnsafe()`).
     */

    //@@{ 缓冲区_:Buffer }
    新建(大小: 数字): 缓冲区_;
    /**
     * Allocates a new buffer containing the given {array} of octets.
     *
     * @param array The octets to store.
     * @deprecated since v10.0.0 - Use `Buffer.from(array)` instead.
     */

    //@@{ 正整数数组8_:Uint8Array, 缓冲区_:Buffer }
    新建(数组: 正整数数组8_): 缓冲区_;
    /**
     * Produces a Buffer backed by the same allocated memory as
     * the given {ArrayBuffer}/{SharedArrayBuffer}.
     *
     *
     * @param arrayBuffer The ArrayBuffer with which to share memory.
     * @deprecated since v10.0.0 - Use `Buffer.from(arrayBuffer[, byteOffset[, length]])` instead.
     */

    //@@{ 数组缓冲区_:ArrayBuffer, 共享数组缓冲区_:SharedArrayBuffer, 缓冲区_:Buffer }
    新建(数组缓冲区: 数组缓冲区_ | 共享数组缓冲区_): 缓冲区_;
    /**
     * Allocates a new buffer containing the given {array} of octets.
     *
     * @param array The octets to store.
     * @deprecated since v10.0.0 - Use `Buffer.from(array)` instead.
     */

    //@@{ 缓冲区_:Buffer }
    新建(数组: 任意[]): 缓冲区_;
    /**
     * Copies the passed {buffer} data onto a new {Buffer} instance.
     *
     * @param buffer The buffer to copy.
     * @deprecated since v10.0.0 - Use `Buffer.from(buffer)` instead.
     */

    //@@{ 缓冲区_:Buffer }
    新建(缓冲区: 缓冲区_): 缓冲区_;

    //@@{ 原型:prototype, 缓冲区_:Buffer }
    原型: 缓冲区_;
    /**
     * When passed a reference to the .buffer property of a TypedArray instance,
     * the newly created Buffer will share the same allocated memory as the TypedArray.
     * The optional {byteOffset} and {length} arguments specify a memory range
     * within the {arrayBuffer} that will be shared by the Buffer.
     *
     * @param arrayBuffer The .buffer property of any TypedArray or a new ArrayBuffer()
     */

    //@@{ 来自:from, 数组缓冲区_:ArrayBuffer, 共享数组缓冲区_:SharedArrayBuffer, 缓冲区_:Buffer }
    来自(数组缓冲区: 数组缓冲区_ | 共享数组缓冲区_, 字节偏移?: 数字, 长度?: 数字): 缓冲区_;
    /**
     * Creates a new Buffer using the passed {data}
     * @param data data to create a new Buffer
     */

    //@@{ 来自:from, 缓冲区_:Buffer }
    来自(数据: 数字[]): 缓冲区_;

    //@@{ 来自:from, 正整数数组8_:Uint8Array, 缓冲区_:Buffer }
    来自(数据: 正整数数组8_): 缓冲区_;
    /**
     * Creates a new Buffer containing the given JavaScript string {str}.
     * If provided, the {encoding} parameter identifies the character encoding.
     * If not provided, {encoding} defaults to 'utf8'.
     */

    //@@{ 来自:from, 缓冲区编码_:BufferEncoding, 缓冲区_:Buffer }
    来自(字符串: 文字, 编码?: 缓冲区编码_): 缓冲区_;
    /**
     * Creates a new Buffer using the passed {data}
     * @param values to create a new Buffer
     */

    //@@{ 属于:of, 缓冲区_:Buffer }
    属于(...项目组: 数字[]): 缓冲区_;
    /**
     * Returns true if {obj} is a Buffer
     *
     * @param obj object to test.
     */

    //@@{ 是缓冲区:isBuffer, 缓冲区_:Buffer }
    是缓冲区(对象: 任意): 对象 作为 缓冲区_;
    /**
     * Returns true if {encoding} is a valid encoding argument.
     * Valid string encodings in Node 0.12: 'ascii'|'utf8'|'utf16le'|'ucs2'(alias of 'utf16le')|'base64'|'binary'(deprecated)|'hex'
     *
     * @param encoding string to test.
     */

    //@@{ 是编码:isEncoding, 缓冲区编码_:BufferEncoding }
    是编码(编码: 文字): 编码 作为 缓冲区编码_
    /**
     * Gives the actual byte length of a string. encoding defaults to 'utf8'.
     * This is not the same as String.prototype.length since that returns the number of characters in a string.
     *
     * @param string string to test.
     * @param encoding encoding used to evaluate (defaults to 'utf8')
     */

    //@@{ 字节长度:byteLength, 类型数组_:TypedArray, 数据视图_:DataView, 数组缓冲区_:ArrayBuffer }
    //@@{ 共享数组缓冲区_:SharedArrayBuffer, 缓冲区编码_:BufferEncoding }
    字节长度(文字: 文字 | NodeJS.类型数组_ | 数据视图_ | 数组缓冲区_ | 共享数组缓冲区_, 编码?: 缓冲区编码_): 数字;
    /**
     * Returns a buffer which is the result of concatenating all the buffers in the list together.
     *
     * If the list has no items, or if the totalLength is 0, then it returns a zero-length buffer.
     * If the list has exactly one item, then the first item of the list is returned.
     * If the list has more than one item, then a new Buffer is created.
     *
     * @param list An array of Buffer objects to concatenate
     * @param totalLength Total length of the buffers when concatenated.
     *   If totalLength is not provided, it is read from the buffers in the list. However, this adds an additional loop to the function, so it is faster to provide the length explicitly.
     */

    //@@{ 连接:concat, 正整数数组8_:Uint8Array, 缓冲区_:Buffer }
    连接(列表: 正整数数组8_[], 总长度?: 数字): 缓冲区_;
    /**
     * The same as buf1.compare(buf2).
     */

    //@@{ 比较:compare, 正整数数组8_:Uint8Array }
    比较(缓冲1: 正整数数组8_, 缓冲2: 正整数数组8_): 数字;
    /**
     * Allocates a new buffer of {size} octets.
     *
     * @param size count of octets to allocate.
     * @param fill if specified, buffer will be initialized by calling buf.fill(fill).
     *    If parameter is omitted, buffer will be filled with zeros.
     * @param encoding encoding used for call to buf.fill while initalizing
     */

    //@@{ 分配:alloc, 缓冲区_:Buffer, 缓冲区编码_:BufferEncoding }
    分配(大小: 数字, 填充?: 文字 | 缓冲区_ | 数字, 编码?: 缓冲区编码_): 缓冲区_;
    /**
     * Allocates a new buffer of {size} octets, leaving memory not initialized, so the contents
     * of the newly created Buffer are unknown and may contain sensitive data.
     *
     * @param size count of octets to allocate
     */

    //@@{ 分配不安全:allocUnsafe, 缓冲区_:Buffer }
    分配不安全(大小: 数字): 缓冲区_;
    /**
     * Allocates a new non-pooled buffer of {size} octets, leaving memory not initialized, so the contents
     * of the newly created Buffer are unknown and may contain sensitive data.
     *
     * @param size count of octets to allocate
     */

    //@@{ 分配不安全的慢缓冲区:allocUnsafeSlow, 缓冲区_:Buffer }
    分配不安全的慢缓冲区(大小: 数字): 缓冲区_;
    /**
     * This is the number of bytes used to determine the size of pre-allocated, internal Buffer instances used for pooling. This value may be modified.
     */

    //@@{ 池大小:poolSize }
    池大小: 数字;
};

/*----------------------------------------------*
*                                               *
*               GLOBAL INTERFACES               *
*                                               *
*-----------------------------------------------*/
声明 名域 NodeJS {

    //@@{ 检查选项_:InspectOptions }
    接口 检查选项_ {
        /**
         * If set to `true`, getters are going to be
         * inspected as well. If set to `'get'` only getters without setter are going
         * to be inspected. If set to `'set'` only getters having a corresponding
         * setter are going to be inspected. This might cause side effects depending on
         * the getter function.
         * @default `false`
         */

        //@@{ 获取测试:getters, "获取":"get", "设置":"set" }
        获取测试?: "获取" | "设置" | 真假;

        //@@{ 显示隐藏:showHidden }
        显示隐藏?: 真假;
        /**
         * @default 2
         */

        //@@{ 深度:depth }
        深度?: 数字 | 空值;

        //@@{ 颜色集:colors }
        颜色集?: 真假;

        //@@{ 自定义检查:customInspect }
        自定义检查?: 真假;

        //@@{ 显示代理:showProxy }
        显示代理?: 真假;

        //@@{ 最大数组长度:maxArrayLength }
        最大数组长度?: 数字 | 空值;

        //@@{ 换行长度:breakLength }
        换行长度?: 数字;
        /**
         * Setting this to `false` causes each object key
         * to be displayed on a new line. It will also add new lines to text that is
         * longer than `breakLength`. If set to a number, the most `n` inner elements
         * are united on a single line as long as all properties fit into
         * `breakLength`. Short array elements are also grouped together. Note that no
         * text will be reduced below 16 characters, no matter the `breakLength` size.
         * For more information, see the example below.
         * @default `true`
         */

        //@@{ 紧凑:compact }
        紧凑?: 真假 | 数字;

        //@@{ 排序的:sorted }
        排序的?: 真假 | ((a: 文字, b: 文字) => 数字);
    }

    //@@{ 控制台构造函数选项_:ConsoleConstructorOptions }
    接口 控制台构造函数选项_ {

        //@@{ 标准输出:stdout, 可写流_:WritableStream }
        标准输出: 可写流_;

        //@@{ 标准错误:stderr, 可写流_:WritableStream }
        标准错误?: 可写流_;

        //@@{ 忽略错误:ignoreErrors }
        忽略错误?: 真假;

        //@@{ 色彩模式:colorMode, "自动":"auto" }
        色彩模式?: 真假 | "自动";

        //@@{ 检查选项:inspectOptions, 检查选项_:InspectOptions }
        检查选项?: 检查选项_;
    }

    //@@{ 控制台构造函数_:ConsoleConstructor }
    接口 控制台构造函数_ {

        //@@{ 原型:prototype, 控制台_:Console }
        原型: 控制台_;

        //@@{ 可写流_:WritableStream, 控制台_:Console }
        新建(标准输出: 可写流_, 标准错误?: 可写流_, 忽略错误?: 真假): 控制台_;

        //@@{ 控制台构造函数选项_:ConsoleConstructorOptions, 控制台_:Console }
        新建(选项组: 控制台构造函数选项_): 控制台_;
    }

    //@@{ 呼叫站点_:CallSite }
    接口 呼叫站点_ {
        /**
         * Value of "this"
         */

        //@@{ 获取本体:getThis }
        获取本体(): 任意;

        /**
         * Type of "this" as a string.
         * This is the name of the function stored in the constructor field of
         * "this", if available.  Otherwise the object's [[Class]] internal
         * property.
         */

        //@@{ 获取类型名称:getTypeName }
        获取类型名称(): 文字 | 空值;

        /**
         * Current function
         */

        //@@{ 获取函数:getFunction, 函数_:Function }
        获取函数(): 函数_ | 未定;

        /**
         * Name of the current function, typically its name property.
         * If a name property is not available an attempt will be made to try
         * to infer a name from the function's context.
         */

        //@@{ 获取函数名:getFunctionName }
        获取函数名(): 文字 | 空值;

        /**
         * Name of the property [of "this" or one of its prototypes] that holds
         * the current function
         */

        //@@{ 获取方法名称:getMethodName }
        获取方法名称(): 文字 | 空值;

        /**
         * Name of the script [if this function was defined in a script]
         */

        //@@{ 获取文件名:getFileName }
        获取文件名(): 文字 | 空值;

        /**
         * Current line number [if this function was defined in a script]
         */

        //@@{ 获取行号:getLineNumber }
        获取行号(): 数字 | 空值;

        /**
         * Current column number [if this function was defined in a script]
         */

        //@@{ 获取列号:getColumnNumber }
        获取列号(): 数字 | 空值;

        /**
         * A call site object representing the location where eval was called
         * [if this function was created using a call to eval]
         */

        //@@{ 获得原始起源:getEvalOrigin }
        获得原始起源(): 文字 | 未定;

        /**
         * Is this a toplevel invocation, that is, is "this" the global object?
         */

        //@@{ 是顶级:isToplevel }
        是顶级(): 真假;

        /**
         * Does this call take place in code defined by a call to eval?
         */

        //@@{ 是执行:isEval }
        是执行(): 真假;

        /**
         * Is this call in native V8 code?
         */

        //@@{ 是本机:isNative }
        是本机(): 真假;

        /**
         * Is this a constructor call?
         */

        //@@{ 是构造函数:isConstructor }
        是构造函数(): 真假;
    }

    //@@{ 错误异常_:ErrnoException, 错误_:Error }
    接口 错误异常_ 扩展 错误_ {

        //@@{ 错误编号:errno }
        错误编号?: 数字;

        //@@{ 代码:code }
        代码?: 文字;

        //@@{ 路径:path }
        路径?: 文字;

        //@@{ 系统调用:syscall }
        系统调用?: 文字;

        //@@{ 堆栈:stack }
        堆栈?: 文字;
    }

    //@@{ 事件发生器_:EventEmitter }
    类别 事件发生器_ {

        //@@{ 添加监听器:addListener }
        添加监听器(事件: 文字 | 符号, 监听器: (...参数组: 任意[]) => 无值): 本体;

        //@@{ 正在:on }
        正在(事件: 文字 | 符号, 监听器: (...参数组: 任意[]) => 无值): 本体;

        //@@{ 一次:once }
        一次(事件: 文字 | 符号, 监听器: (...参数组: 任意[]) => 无值): 本体;

        //@@{ 移除监听器:removeListener }
        移除监听器(事件: 文字 | 符号, 监听器: (...参数组: 任意[]) => 无值): 本体;

        //@@{ 关:off }
        关(事件: 文字 | 符号, 监听器: (...参数组: 任意[]) => 无值): 本体;

        //@@{ 删除所有监听器:removeAllListeners }
        删除所有监听器(事件?: 文字 | 符号): 本体;

        //@@{ 设置最大监听器:setMaxListeners }
        设置最大监听器(n: 数字): 本体;

        //@@{ 获取最大监听器:getMaxListeners }
        获取最大监听器(): 数字;

        //@@{ 监听者:listeners, 函数_:Function }
        监听者(事件: 文字 | 符号): 函数_[];

        //@@{ 原始监听者:rawListeners, 函数_:Function }
        原始监听者(事件: 文字 | 符号): 函数_[];

        //@@{ 发出:emit }
        发出(事件: 文字 | 符号, ...参数组: 任意[]): 真假;

        //@@{ 监听者数量:listenerCount }
        监听者数量(类型: 文字 | 符号): 数字;
        // Added in Node 6...

        //@@{ 预处理监听器:prependListener }
        预处理监听器(事件: 文字 | 符号, 监听器: (...参数组: 任意[]) => 无值): 本体;

        //@@{ 预处理一次监听器:prependOnceListener }
        预处理一次监听器(事件: 文字 | 符号, 监听器: (...参数组: 任意[]) => 无值): 本体;

        //@@{ 事件名称:eventNames, 数组_:Array }
        事件名称(): 数组_<文字 | 符号>;
    }

    //@@{ 可读流_:ReadableStream, 事件发生器_:EventEmitter }
    接口 可读流_ 扩展 事件发生器_ {

        //@@{ 可读的:readable }
        可读的: 真假;

        //@@{ 读:read, 缓冲区_:Buffer }
        读(大小?: 数字): 文字 | 缓冲区_;

        //@@{ 设置编码:setEncoding }
        设置编码(编码: 文字): 本体;

        //@@{ 暂停:pause }
        暂停(): 本体;

        //@@{ 恢复:resume }
        恢复(): 本体;

        //@@{ 是暂停的:isPaused }
        是暂停的(): 真假;

        //@@{ 管道:pipe, 可写流_:WritableStream, 结束:end }
        管道<T 扩展 可写流_>(目的地: T, 选项组?: { 结束?: 真假; }): T;

        //@@{ 取消管道:unpipe, 可写流_:WritableStream }
        取消管道(目的地?: 可写流_): 本体;

        //@@{ 推入:unshift, 缓冲区_:Buffer, 正整数数组8_:Uint8Array }
        推入(块: 文字 | 缓冲区_ | 正整数数组8_): 无值;

        //@@{ 包装:wrap, 可读流_:ReadableStream }
        包装(旧流: 可读流_): 本体;

        //@@{ 符号_:Symbol, 异步迭代器:asyncIterator, 异步可迭代迭代器_:AsyncIterableIterator }
        //@@{ 缓冲区_:Buffer }
        [符号_.异步迭代器](): 异步可迭代迭代器_<文字 | 缓冲区_>;
    }

    //@@{ 可写流_:WritableStream, 事件发生器_:EventEmitter }
    接口 可写流_ 扩展 事件发生器_ {

        //@@{ 可写的:writable }
        可写的: 真假;

        //@@{ 写:write, 缓冲区_:Buffer, 正整数数组8_:Uint8Array, 错误_:Error }
        写(缓冲区: 缓冲区_ | 正整数数组8_ | 文字, 回调?: (错?: 错误_ | 空值) => 无值): 真假;

        //@@{ 写:write, 错误_:Error }
        写(字符串: 文字, 编码?: 文字, 回调?: (错?: 错误_ | 空值) => 无值): 真假;

        //@@{ 结束:end }
        结束(回调?: () => 无值): 无值;

        //@@{ 结束:end, 正整数数组8_:Uint8Array, 缓冲区_:Buffer }
        结束(数据: 文字 | 正整数数组8_ | 缓冲区_, 回调?: () => 无值): 无值;

        //@@{ 结束:end }
        结束(字符串: 文字, 编码?: 文字, 回调?: () => 无值): 无值;
    }

    //@@{ 读写流_:ReadWriteStream, 可读流_:ReadableStream, 可写流_:WritableStream }
    接口 读写流_ 扩展 可读流_, 可写流_ { }

    //@@{ 事件组_:Events, 事件发生器_:EventEmitter }
    接口 事件组_ 扩展 事件发生器_ { }

    //@@{ 域_:Domain, 事件组_:Events }
    接口 域_ 扩展 事件组_ {

        //@@{ 运行:run }
        运行<T>(运行函数: (...参数组: 任意[]) => T, ...参数组: 任意[]): T;

        //@@{ 添加:add, 事件发生器_:EventEmitter, 计时器_:Timer }
        添加(发射器: 事件发生器_ | 计时器_): 无值;

        //@@{ 移除:remove, 事件发生器_:EventEmitter, 计时器_:Timer }
        移除(发射器: 事件发生器_ | 计时器_): 无值;

        //@@{ 绑定:bind, 函数_:Function }
        绑定<T 扩展 函数_>(回调: T): T;

        //@@{ 拦截:intercept, 函数_:Function }
        拦截<T 扩展 函数_>(回调: T): T;

        //@@{ 添加监听器:addListener }
        添加监听器(事件: 文字, 监听器: (...参数组: 任意[]) => 无值): 本体;

        //@@{ 正在:on }
        正在(事件: 文字, 监听器: (...参数组: 任意[]) => 无值): 本体;

        //@@{ 一次:once }
        一次(事件: 文字, 监听器: (...参数组: 任意[]) => 无值): 本体;

        //@@{ 移除监听器:removeListener }
        移除监听器(事件: 文字, 监听器: (...参数组: 任意[]) => 无值): 本体;

        //@@{ 删除所有监听器:removeAllListeners }
        删除所有监听器(事件?: 文字): 本体;
    }

    //@@{ 内存使用情况_:MemoryUsage }
    接口 内存使用情况_ {

        //@@{ 常驻内存:rss }
        常驻内存: 数字;

        //@@{ 已申请内存:heapTotal }
        已申请内存: 数字;

        //@@{ 已使用内存:heapUsed }
        已使用内存: 数字;

        //@@{ 外部:external }
        外部: 数字;
    }

    //@@{ Cpu使用率_:CpuUsage }
    接口 Cpu使用率_ {

        //@@{ 用户:user }
        用户: 数字;

        //@@{ 系统:system }
        系统: 数字;
    }

    //@@{ 进程释放_:ProcessRelease }
    接口 进程释放_ {

        //@@{ 名称:name }
        名称: 文字;

        //@@{ 源Url:sourceUrl }
        源Url?: 文字;

        //@@{ 头Url:headersUrl }
        头Url?: 文字;

        //@@{ 库Url:libUrl }
        库Url?: 文字;
        lts?: 文字;
    }

    //@@{ 进程版本_:ProcessVersions }
    接口 进程版本_ {

        //@@{ http_解析器:http_parser }
        http_解析器: 文字;
        node: 文字;
        v8: 文字;

        //@@{ 异步DNS解析库:ares }
        异步DNS解析库: 文字;

        //@@{ 异步处理:uv }
        异步处理: 文字;

        //@@{ 数据压缩:zlib }
        数据压缩: 文字;

        //@@{ 模块组:modules }
        模块组: 文字;

        //@@{ 安全套接字层密码库:openssl }
        安全套接字层密码库: 文字;
    }

    //@@{ 平台_:Platform }
    类型 平台_ = 'aix'
        | 'android'
        | 'darwin'
        | 'freebsd'
        | 'linux'
        | 'openbsd'
        | 'sunos'
        | 'win32'
        | 'cygwin';

    //@@{ 信号_:Signals }
    类型 信号_ =

        //@@{ "__信号_中止信号__":"SIGABRT", "__信号_定时器信号__":"SIGALRM", "__信号_总线错误__":"SIGBUS" }
        //@@{ "__信号_子终止信号__":"SIGCHLD", "__信号_继续信号__":"SIGCONT", "__信号_浮点异常__":"SIGFPE" }
        //@@{ "__信号_挂机信号__":"SIGHUP", "__信号_非法指令__":"SIGILL", "__信号_键盘中断__":"SIGINT" }
        //@@{ "__信号_IO信号__":"SIGIO" }
        "__信号_中止信号__" | "__信号_定时器信号__" | "__信号_总线错误__" | "__信号_子终止信号__" | "__信号_继续信号__" | "__信号_浮点异常__" | "__信号_挂机信号__" | "__信号_非法指令__" | "__信号_键盘中断__" | "__信号_IO信号__" |

        //@@{ "__信号_物联网信号__":"SIGIOT", "__信号_杀死信号__":"SIGKILL", "__信号_管道信号__":"SIGPIPE" }
        //@@{ "__信号_可移植信号__":"SIGPOLL", "__信号_计时器过期__":"SIGPROF", "__信号_电源故障__":"SIGPWR" }
        //@@{ "__信号_退出键盘__":"SIGQUIT", "__信号_无效内存引用__":"SIGSEGV", "__信号_堆栈错误__":"SIGSTKFLT" }
        "__信号_物联网信号__" | "__信号_杀死信号__" | "__信号_管道信号__" | "__信号_可移植信号__" | "__信号_计时器过期__" | "__信号_电源故障__" | "__信号_退出键盘__" | "__信号_无效内存引用__" | "__信号_堆栈错误__" |

        //@@{ "__信号_进程停止__":"SIGSTOP", "__信号_系统错误__":"SIGSYS", "__信号_终止信号__":"SIGTERM" }
        //@@{ "__信号_断点陷阱__":"SIGTRAP", "__信号_终端输入停止__":"SIGTSTP", "__信号_后台终端输入__":"SIGTTIN" }
        //@@{ "__信号_后台终端输出__":"SIGTTOU", "__信号_系统异常__":"SIGUNUSED", "__信号_条件套接字__":"SIGURG" }
        "__信号_进程停止__" | "__信号_系统错误__" | "__信号_终止信号__" | "__信号_断点陷阱__" | "__信号_终端输入停止__" | "__信号_后台终端输入__" | "__信号_后台终端输出__" | "__信号_系统异常__" | "__信号_条件套接字__" |

        //@@{ "__信号_自定义1__":"SIGUSR1", "__信号_自定义2__":"SIGUSR2", "__信号_虚拟时钟__":"SIGVTALRM" }
        //@@{ "__信号_窗口大小调整__":"SIGWINCH", "__信号_CPU超时__":"SIGXCPU", "__信号_文件大小超限__":"SIGXFSZ" }
        //@@{ "__信号_Ctrl加Break中断__":"SIGBREAK", "__信号_文件锁丢失__":"SIGLOST", "__信号_电源错误__":"SIGINFO" }
        "__信号_自定义1__" | "__信号_自定义2__" | "__信号_虚拟时钟__" | "__信号_窗口大小调整__" | "__信号_CPU超时__" | "__信号_文件大小超限__" | "__信号_Ctrl加Break中断__" | "__信号_文件锁丢失__" | "__信号_电源错误__";

    //@@{ 多解析类型_:MultipleResolveType, "解决":"resolve", "拒绝":"reject" }
    类型 多解析类型_ = "解决" | "拒绝";

    //@@{ 之前退出监听器_:BeforeExitListener }
    类型 之前退出监听器_ = (代码: 数字) => 无值;

    //@@{ 断开连接监听器_:DisconnectListener }
    类型 断开连接监听器_ = () => 无值;

    //@@{ 退出监听器_:ExitListener }
    类型 退出监听器_ = (代码: 数字) => 无值;

    //@@{ 拒绝处理监听器_:RejectionHandledListener, 预设_:Promise }
    类型 拒绝处理监听器_ = (预设: 预设_<任意>) => 无值;

    //@@{ 异常监听器_:UncaughtExceptionListener, 错误_:Error }
    类型 异常监听器_ = (错误: 错误_) => 无值;

    //@@{ 未处理的拒绝监听器_:UnhandledRejectionListener, 预设_:Promise }
    类型 未处理的拒绝监听器_ = (原因: {} | 空值 | 未定, 预设: 预设_<任意>) => 无值;

    //@@{ 警告监听器_:WarningListener, 错误_:Error }
    类型 警告监听器_ = (警告: 错误_) => 无值;

    //@@{ 消息监听器_:MessageListener }
    类型 消息监听器_ = (消息: 任意, 发送处理: 任意) => 无值;

    //@@{ 信号监听器_:SignalsListener, 信号_:Signals }
    类型 信号监听器_ = (信号: 信号_) => 无值;

    //@@{ 新监听器监听器_:NewListenerListener }
    类型 新监听器监听器_ = (类型: 文字 | 符号, 监听器: (...参数组: 任意[]) => 无值) => 无值;

    //@@{ 删除监听器监听器_:RemoveListenerListener }
    类型 删除监听器监听器_ = (类型: 文字 | 符号, 监听器: (...参数组: 任意[]) => 无值) => 无值;

    //@@{ 多解析监听器_:MultipleResolveListener, 多解析类型_:MultipleResolveType, 预设_:Promise }
    类型 多解析监听器_ = (类型: 多解析类型_, 预设: 预设_<任意>, 值: 任意) => 无值;

    //@@{ 套接字_:Socket, 读写流_:ReadWriteStream }
    接口 套接字_ 扩展 读写流_ {

        //@@{ 是绑定终端:isTTY }
        是绑定终端?: 为真;
    }

    //@@{ 进程环境变量_:ProcessEnv }
    接口 进程环境变量_ {
        [键: 文字]: 文字 | 未定;
    }

    //@@{ 写流_:WriteStream, 套接字_:Socket }
    接口 写流_ 扩展 套接字_ {

        //@@{ 可写高水位线:writableHighWaterMark }
        只读 可写高水位线: 数字;

        //@@{ 可写长度:writableLength }
        只读 可写长度: 数字;

        //@@{ 列组:columns }
        列组?: 数字;

        //@@{ 行组:rows }
        行组?: 数字;

        //@@{ _写:_write, 错误_:Error }
        _写(块: 任意, 编码: 文字, 回调: (错?: 空值 | 错误_) => 无值): 无值;

        //@@{ _销毁:_destroy, 错误_:Error }
        _销毁(错: 错误_ | 空值, 回调: (错?: 空值 | 错误_) => 无值): 无值;

        //@@{ _最后:_final, 错误_:Error }
        _最后(回调: (错?: 空值 | 错误_) => 无值): 无值;

        //@@{ 设置默认编码:setDefaultEncoding }
        设置默认编码(编码: 文字): 本体;

        //@@{ 写入内存缓冲区:cork }
        写入内存缓冲区(): 无值;

        //@@{ 输出内存缓冲区:uncork }
        输出内存缓冲区(): 无值;

        //@@{ 销毁:destroy, 错误_:Error }
        销毁(错误?: 错误_): 无值;
    }

    //@@{ 读流_:ReadStream, 套接字_:Socket }
    接口 读流_ 扩展 套接字_ {

        //@@{ 可读高水位线:readableHighWaterMark }
        只读 可读高水位线: 数字;

        //@@{ 可读长度:readableLength }
        只读 可读长度: 数字;

        //@@{ 是原始:isRaw }
        是原始?: 真假;

        //@@{ 设置原始模式:setRawMode }
        设置原始模式?(模式: 真假): 无值;

        //@@{ _读:_read }
        _读(大小: 数字): 无值;

        //@@{ _销毁:_destroy, 错误_:Error }
        _销毁(错: 错误_ | 空值, 回调: (错?: 空值 | 错误_) => 无值): 无值;

        //@@{ 压入:push }
        压入(块: 任意, 编码?: 文字): 真假;

        //@@{ 销毁:destroy, 错误_:Error }
        销毁(错误?: 错误_): 无值;
    }

    //@@{ HR时间_:HRTime }
    接口 HR时间_ {
        (时间?: [数字, 数字]): [数字, 数字];
    }

    //@@{ 进程报告_:ProcessReport }
    接口 进程报告_ {
        /**
         * Directory where the report is written.
         * working directory of the Node.js process.
         * @default '' indicating that reports are written to the current
         */

        //@@{ 目录:directory }
        目录: 文字;

        /**
         * Filename where the report is written.
         * The default value is the empty string.
         * @default '' the output filename will be comprised of a timestamp,
         * PID, and sequence number.
         */

        //@@{ 文件名称:filename }
        文件名称: 文字;

        /**
         * Returns a JSON-formatted diagnostic report for the running process.
         * The report's JavaScript stack trace is taken from err, if present.
         */

        //@@{ 获取报告:getReport, 错误_:Error }
        获取报告(错?: 错误_): 文字;

        /**
         * If true, a diagnostic report is generated on fatal errors,
         * such as out of memory errors or failed C++ assertions.
         * @default false
         */

        //@@{ 报告致命错误:reportOnFatalError }
        报告致命错误: 真假;

        /**
         * If true, a diagnostic report is generated when the process
         * receives the signal specified by process.report.signal.
         * @defaul false
         */

        //@@{ 报告信号:reportOnSignal }
        报告信号: 真假;

        /**
         * If true, a diagnostic report is generated on uncaught exception.
         * @default false
         */

        //@@{ 报告未捕获异常:reportOnUncaughtException }
        报告未捕获异常: 真假;

        /**
         * The signal used to trigger the creation of a diagnostic report.
         * @default 'SIGUSR2'
         */

        //@@{ 信号:signal, 信号_:Signals }
        信号: 信号_;

        /**
         * Writes a diagnostic report to a file. If filename is not provided, the default filename
         * includes the date, time, PID, and a sequence number.
         * The report's JavaScript stack trace is taken from err, if present.
         *
         * @param fileName Name of the file where the report is written.
         * This should be a relative path, that will be appended to the directory specified in
         * `process.report.directory`, or the current working directory of the Node.js process,
         * if unspecified.
         * @param error A custom error used for reporting the JavaScript stack.
         * @return Filename of the generated report.
         */

        //@@{ 撰写报告:writeReport }
        撰写报告(文件名?: 文字): 文字;

        //@@{ 撰写报告:writeReport, 错误_:Error }
        撰写报告(错误?: 错误_): 文字;

        //@@{ 撰写报告:writeReport, 错误_:Error }
        撰写报告(文件名?: 文字, 错?: 错误_): 文字;
    }

    //@@{ 进程_:Process, 事件发生器_:EventEmitter }
    接口 进程_ 扩展 事件发生器_ {
        /**
         * Can also be a tty.WriteStream, not typed due to limitation.s
         */

        //@@{ 标准输出:stdout, 写流_:WriteStream }
        标准输出: 写流_;
        /**
         * Can also be a tty.WriteStream, not typed due to limitation.s
         */

        //@@{ 标准错误:stderr, 写流_:WriteStream }
        标准错误: 写流_;

        //@@{ 标准输入:stdin, 读流_:ReadStream }
        标准输入: 读流_;

        //@@{ 打开标准输入:openStdin, 套接字_:Socket }
        打开标准输入(): 套接字_;

        //@@{ 参数v:argv }
        参数v: 文字[];

        //@@{ 参数v0:argv0 }
        参数v0: 文字;

        //@@{ 执行参数v:execArgv }
        执行参数v: 文字[];

        //@@{ 执行路径:execPath }
        执行路径: 文字;

        //@@{ 中止:abort }
        中止(): 无值;

        //@@{ 改变工作目录:chdir }
        改变工作目录(目录: 文字): 无值;

        //@@{ 工作目录:cwd }
        工作目录(): 文字;

        //@@{ 调试端口:debugPort }
        调试端口: 数字;

        //@@{ 发出警告:emitWarning, 错误_:Error, 函数_:Function }
        发出警告(警告: 文字 | 错误_, 名称?: 文字, 限制生成?: 函数_): 无值;

        //@@{ 环境变量:env, 进程环境变量_:ProcessEnv }
        环境变量: 进程环境变量_;

        //@@{ 退出:exit }
        退出(代码?: 数字): 不及;

        //@@{ 退出代码:exitCode }
        退出代码: 数字;

        //@@{ 获取组Id:getgid }
        获取组Id(): 数字;

        //@@{ 设置组Id:setgid }
        设置组Id(id: 数字 | 文字): 无值;

        //@@{ 获取用户Id:getuid }
        获取用户Id(): 数字;

        //@@{ 设置用户Id:setuid }
        设置用户Id(id: 数字 | 文字): 无值;

        //@@{ 获取用户id:geteuid }
        获取用户id(): 数字;

        //@@{ 设置用户id:seteuid }
        设置用户id(id: 数字 | 文字): 无值;

        //@@{ 获取组织id:getegid }
        获取组织id(): 数字;

        //@@{ 设置组织id:setegid }
        设置组织id(id: 数字 | 文字): 无值;

        //@@{ 获取组:getgroups }
        获取组(): 数字[];

        //@@{ 设置集群:setgroups, 数组_:Array }
        设置集群(集团: 数组_<文字 | 数字>): 无值;

        //@@{ 设置未捕获的异常捕获回调:setUncaughtExceptionCaptureCallback, 错误_:Error }
        设置未捕获的异常捕获回调(回调: ((错: 错误_) => 无值) | 空值): 无值;

        //@@{ 具有未捕获的异常捕获回调:hasUncaughtExceptionCaptureCallback }
        具有未捕获的异常捕获回调(): 真假;

        //@@{ 版本:version }
        版本: 文字;

        //@@{ 版本组:versions, 进程版本_:ProcessVersions }
        版本组: 进程版本_;

        //@@{ 配置:config }
        配置: {

            //@@{ 目标_默认:target_defaults }
            目标_默认: {

                //@@{ c选项:cflags }
                c选项: 任意[];

                //@@{ 默认_配置:default_configuration }
                默认_配置: 文字;

                //@@{ 定义了:defines }
                定义了: 文字[];

                //@@{ 包括_目录:include_dirs }
                包括_目录: 文字[];

                //@@{ 库目录:libraries }
                库目录: 文字[];
            };

            //@@{ 变量集:variables }
            变量集: {

                //@@{ c语言:clang }
                c语言: 数字;

                //@@{ 主机_处理器架构:host_arch }
                主机_处理器架构: 文字;

                //@@{ node_安装_npm:node_install_npm }
                node_安装_npm: 真假;

                //@@{ node_安装_waf:node_install_waf }
                node_安装_waf: 真假;

                //@@{ node_前缀:node_prefix }
                node_前缀: 文字;

                //@@{ node_共享_openssl:node_shared_openssl }
                node_共享_openssl: 真假;

                //@@{ node_共享_v8:node_shared_v8 }
                node_共享_v8: 真假;

                //@@{ node_共享_zlib:node_shared_zlib }
                node_共享_zlib: 真假;
                node_use_dtrace: 真假;
                node_use_etw: 真假;
                node_use_openssl: 真假;

                //@@{ 目标_处理器架构:target_arch }
                目标_处理器架构: 文字;

                //@@{ v8_无_严格_别名:v8_no_strict_aliasing }
                v8_无_严格_别名: 数字;

                //@@{ v8_使用_快照:v8_use_snapshot }
                v8_使用_快照: 真假;

                //@@{ 可见性:visibility }
                可见性: 文字;
            };
        };

        //@@{ 杀死:kill }
        杀死(pid: 数字, 信号?: 文字 | 数字): 无值;
        pid: 数字;
        ppid: 数字;

        //@@{ 标题:title }
        标题: 文字;

        //@@{ 处理器架构:arch }
        处理器架构: 文字;

        //@@{ 平台:platform, 平台_:Platform }
        平台: 平台_;

        //@@{ 主模块:mainModule, Node模块_:NodeModule }
        主模块?: Node模块_;

        //@@{ 内存使用情况:memoryUsage, 内存使用情况_:MemoryUsage }
        内存使用情况(): 内存使用情况_;

        //@@{ cpu使用率:cpuUsage, Cpu使用率_:CpuUsage }
        cpu使用率(之前的值?: Cpu使用率_): Cpu使用率_;

        //@@{ 下个钩子:nextTick, 函数_:Function }
        下个钩子(回调: 函数_, ...参数组: 任意[]): 无值;

        //@@{ 释放:release, 进程释放_:ProcessRelease }
        释放: 进程释放_;

        //@@{ 特征:features }
        特征: {

            //@@{ 检查员:inspector }
            检查员: 真假;

            //@@{ 调试程序:debug }
            调试程序: 真假;

            //@@{ 异步处理:uv }
            异步处理: 真假;
            ipv6: 真假;
            tls_alpn: 真假;
            tls_sni: 真假;
            tls_ocsp: 真假;
            tls: 真假;
        };
        /**
         * Can only be set if not in worker thread.
         */

        //@@{ 权限掩码:umask }
        权限掩码(掩码?: 数字): 数字;

        //@@{ 运行时间:uptime }
        运行时间(): 数字;

        //@@{ 高精度时间:hrtime, HR时间_:HRTime }
        高精度时间: HR时间_;

        //@@{ 领域:domain, 域_:Domain }
        领域: 域_;

        // Worker

        //@@{ 发送:send, 吞咽误差:swallowErrors, 错误_:Error }
        发送?(消息: 任意, 发送处理?: 任意, 选项组?: { 吞咽误差?: 真假}, 回调?: (错误: 错误_ | 空值) => 无值): 真假;

        //@@{ 断开连接:disconnect }
        断开连接(): 无值;

        //@@{ 连接了:connected }
        连接了: 真假;

        /**
         * The `process.allowedNodeEnvironmentFlags` property is a special,
         * read-only `Set` of flags allowable within the [`NODE_OPTIONS`][]
         * environment variable.
         */

        //@@{ 允许节点环境标志:allowedNodeEnvironmentFlags, 只读集合_:ReadonlySet }
        允许节点环境标志: 只读集合_<文字>;

        /**
         * Only available with `--experimental-report`
         */

        //@@{ 报告:report, 进程报告_:ProcessReport }
        报告?: 进程报告_;

        /**
         * EventEmitter
         *   1. beforeExit
         *   2. disconnect
         *   3. exit
         *   4. message
         *   5. rejectionHandled
         *   6. uncaughtException
         *   7. unhandledRejection
         *   8. warning
         *   9. message
         *  10. <All OS Signals>
         *  11. newListener/removeListener inherited from EventEmitter
         */

        //@@{ 添加监听器:addListener, "在退出之前":"beforeExit", 之前退出监听器_:BeforeExitListener }
        添加监听器(事件: "在退出之前", 监听器: 之前退出监听器_): 本体;

        //@@{ 添加监听器:addListener, "断开连接":"disconnect", 断开连接监听器_:DisconnectListener }
        添加监听器(事件: "断开连接", 监听器: 断开连接监听器_): 本体;

        //@@{ 添加监听器:addListener, "退出":"exit", 退出监听器_:ExitListener }
        添加监听器(事件: "退出", 监听器: 退出监听器_): 本体;

        //@@{ 添加监听器:addListener, "拒绝处理":"rejectionHandled", 拒绝处理监听器_:RejectionHandledListener }
        添加监听器(事件: "拒绝处理", 监听器: 拒绝处理监听器_): 本体;

        //@@{ 添加监听器:addListener, "未捕获异常":"uncaughtException", 异常监听器_:UncaughtExceptionListener }
        添加监听器(事件: "未捕获异常", 监听器: 异常监听器_): 本体;

        //@@{ 添加监听器:addListener, "未处理的拒绝":"unhandledRejection", 未处理的拒绝监听器_:UnhandledRejectionListener }
        添加监听器(事件: "未处理的拒绝", 监听器: 未处理的拒绝监听器_): 本体;

        //@@{ 添加监听器:addListener, "警告":"warning", 警告监听器_:WarningListener }
        添加监听器(事件: "警告", 监听器: 警告监听器_): 本体;

        //@@{ 添加监听器:addListener, "消息":"message", 消息监听器_:MessageListener }
        添加监听器(事件: "消息", 监听器: 消息监听器_): 本体;

        //@@{ 添加监听器:addListener, 信号_:Signals, 信号监听器_:SignalsListener }
        添加监听器(事件: 信号_, 监听器: 信号监听器_): 本体;

        //@@{ 添加监听器:addListener, "新监听器":"newListener", 新监听器监听器_:NewListenerListener }
        添加监听器(事件: "新监听器", 监听器: 新监听器监听器_): 本体;

        //@@{ 添加监听器:addListener, "移除监听器":"removeListener", 删除监听器监听器_:RemoveListenerListener }
        添加监听器(事件: "移除监听器", 监听器: 删除监听器监听器_): 本体;

        //@@{ 添加监听器:addListener, "多路解析":"multipleResolves", 多解析监听器_:MultipleResolveListener }
        添加监听器(事件: "多路解析", 监听器: 多解析监听器_): 本体;

        //@@{ 发出:emit, "在退出之前":"beforeExit" }
        发出(事件: "在退出之前", 代码: 数字): 真假;

        //@@{ 发出:emit, "断开连接":"disconnect" }
        发出(事件: "断开连接"): 真假;

        //@@{ 发出:emit, "退出":"exit" }
        发出(事件: "退出", 代码: 数字): 真假;

        //@@{ 发出:emit, "拒绝处理":"rejectionHandled", 预设_:Promise }
        发出(事件: "拒绝处理", 预设: 预设_<任意>): 真假;

        //@@{ 发出:emit, "未捕获异常":"uncaughtException", 错误_:Error }
        发出(事件: "未捕获异常", 错误: 错误_): 真假;

        //@@{ 发出:emit, "未处理的拒绝":"unhandledRejection", 预设_:Promise }
        发出(事件: "未处理的拒绝", 原因: 任意, 预设: 预设_<任意>): 真假;

        //@@{ 发出:emit, "警告":"warning", 错误_:Error }
        发出(事件: "警告", 警告: 错误_): 真假;

        //@@{ 发出:emit, "消息":"message" }
        发出(事件: "消息", 消息: 任意, 发送处理: 任意): 本体;

        //@@{ 发出:emit, 信号_:Signals }
        发出(事件: 信号_, 信号: 信号_): 真假;

        //@@{ 发出:emit, "新监听器":"newListener" }
        发出(事件: "新监听器", 事件名称: 文字 | 符号, 监听器: (...参数组: 任意[]) => 无值): 本体;

        //@@{ 发出:emit, "移除监听器":"removeListener" }
        发出(事件: "移除监听器", 事件名称: 文字, 监听器: (...参数组: 任意[]) => 无值): 本体;

        //@@{ 发出:emit, "多路解析":"multipleResolves", 多解析监听器_:MultipleResolveListener }
        发出(事件: "多路解析", 监听器: 多解析监听器_): 本体;

        //@@{ 正在:on, "在退出之前":"beforeExit", 之前退出监听器_:BeforeExitListener }
        正在(事件: "在退出之前", 监听器: 之前退出监听器_): 本体;

        //@@{ 正在:on, "断开连接":"disconnect", 断开连接监听器_:DisconnectListener }
        正在(事件: "断开连接", 监听器: 断开连接监听器_): 本体;

        //@@{ 正在:on, "退出":"exit", 退出监听器_:ExitListener }
        正在(事件: "退出", 监听器: 退出监听器_): 本体;

        //@@{ 正在:on, "拒绝处理":"rejectionHandled", 拒绝处理监听器_:RejectionHandledListener }
        正在(事件: "拒绝处理", 监听器: 拒绝处理监听器_): 本体;

        //@@{ 正在:on, "未捕获异常":"uncaughtException", 异常监听器_:UncaughtExceptionListener }
        正在(事件: "未捕获异常", 监听器: 异常监听器_): 本体;

        //@@{ 正在:on, "未处理的拒绝":"unhandledRejection", 未处理的拒绝监听器_:UnhandledRejectionListener }
        正在(事件: "未处理的拒绝", 监听器: 未处理的拒绝监听器_): 本体;

        //@@{ 正在:on, "警告":"warning", 警告监听器_:WarningListener }
        正在(事件: "警告", 监听器: 警告监听器_): 本体;

        //@@{ 正在:on, "消息":"message", 消息监听器_:MessageListener }
        正在(事件: "消息", 监听器: 消息监听器_): 本体;

        //@@{ 正在:on, 信号_:Signals, 信号监听器_:SignalsListener }
        正在(事件: 信号_, 监听器: 信号监听器_): 本体;

        //@@{ 正在:on, "新监听器":"newListener", 新监听器监听器_:NewListenerListener }
        正在(事件: "新监听器", 监听器: 新监听器监听器_): 本体;

        //@@{ 正在:on, "移除监听器":"removeListener", 删除监听器监听器_:RemoveListenerListener }
        正在(事件: "移除监听器", 监听器: 删除监听器监听器_): 本体;

        //@@{ 正在:on, "多路解析":"multipleResolves", 多解析监听器_:MultipleResolveListener }
        正在(事件: "多路解析", 监听器: 多解析监听器_): 本体;

        //@@{ 一次:once, "在退出之前":"beforeExit", 之前退出监听器_:BeforeExitListener }
        一次(事件: "在退出之前", 监听器: 之前退出监听器_): 本体;

        //@@{ 一次:once, "断开连接":"disconnect", 断开连接监听器_:DisconnectListener }
        一次(事件: "断开连接", 监听器: 断开连接监听器_): 本体;

        //@@{ 一次:once, "退出":"exit", 退出监听器_:ExitListener }
        一次(事件: "退出", 监听器: 退出监听器_): 本体;

        //@@{ 一次:once, "拒绝处理":"rejectionHandled", 拒绝处理监听器_:RejectionHandledListener }
        一次(事件: "拒绝处理", 监听器: 拒绝处理监听器_): 本体;

        //@@{ 一次:once, "未捕获异常":"uncaughtException", 异常监听器_:UncaughtExceptionListener }
        一次(事件: "未捕获异常", 监听器: 异常监听器_): 本体;

        //@@{ 一次:once, "未处理的拒绝":"unhandledRejection", 未处理的拒绝监听器_:UnhandledRejectionListener }
        一次(事件: "未处理的拒绝", 监听器: 未处理的拒绝监听器_): 本体;

        //@@{ 一次:once, "警告":"warning", 警告监听器_:WarningListener }
        一次(事件: "警告", 监听器: 警告监听器_): 本体;

        //@@{ 一次:once, "消息":"message", 消息监听器_:MessageListener }
        一次(事件: "消息", 监听器: 消息监听器_): 本体;

        //@@{ 一次:once, 信号_:Signals, 信号监听器_:SignalsListener }
        一次(事件: 信号_, 监听器: 信号监听器_): 本体;

        //@@{ 一次:once, "新监听器":"newListener", 新监听器监听器_:NewListenerListener }
        一次(事件: "新监听器", 监听器: 新监听器监听器_): 本体;

        //@@{ 一次:once, "移除监听器":"removeListener", 删除监听器监听器_:RemoveListenerListener }
        一次(事件: "移除监听器", 监听器: 删除监听器监听器_): 本体;

        //@@{ 一次:once, "多路解析":"multipleResolves", 多解析监听器_:MultipleResolveListener }
        一次(事件: "多路解析", 监听器: 多解析监听器_): 本体;

        //@@{ 预处理监听器:prependListener, "在退出之前":"beforeExit", 之前退出监听器_:BeforeExitListener }
        预处理监听器(事件: "在退出之前", 监听器: 之前退出监听器_): 本体;

        //@@{ 预处理监听器:prependListener, "断开连接":"disconnect", 断开连接监听器_:DisconnectListener }
        预处理监听器(事件: "断开连接", 监听器: 断开连接监听器_): 本体;

        //@@{ 预处理监听器:prependListener, "退出":"exit", 退出监听器_:ExitListener }
        预处理监听器(事件: "退出", 监听器: 退出监听器_): 本体;

        //@@{ 预处理监听器:prependListener, "拒绝处理":"rejectionHandled", 拒绝处理监听器_:RejectionHandledListener }
        预处理监听器(事件: "拒绝处理", 监听器: 拒绝处理监听器_): 本体;

        //@@{ 预处理监听器:prependListener, "未捕获异常":"uncaughtException", 异常监听器_:UncaughtExceptionListener }
        预处理监听器(事件: "未捕获异常", 监听器: 异常监听器_): 本体;

        //@@{ 预处理监听器:prependListener, "未处理的拒绝":"unhandledRejection", 未处理的拒绝监听器_:UnhandledRejectionListener }
        预处理监听器(事件: "未处理的拒绝", 监听器: 未处理的拒绝监听器_): 本体;

        //@@{ 预处理监听器:prependListener, "警告":"warning", 警告监听器_:WarningListener }
        预处理监听器(事件: "警告", 监听器: 警告监听器_): 本体;

        //@@{ 预处理监听器:prependListener, "消息":"message", 消息监听器_:MessageListener }
        预处理监听器(事件: "消息", 监听器: 消息监听器_): 本体;

        //@@{ 预处理监听器:prependListener, 信号_:Signals, 信号监听器_:SignalsListener }
        预处理监听器(事件: 信号_, 监听器: 信号监听器_): 本体;

        //@@{ 预处理监听器:prependListener, "新监听器":"newListener", 新监听器监听器_:NewListenerListener }
        预处理监听器(事件: "新监听器", 监听器: 新监听器监听器_): 本体;

        //@@{ 预处理监听器:prependListener, "移除监听器":"removeListener", 删除监听器监听器_:RemoveListenerListener }
        预处理监听器(事件: "移除监听器", 监听器: 删除监听器监听器_): 本体;

        //@@{ 预处理监听器:prependListener, "多路解析":"multipleResolves", 多解析监听器_:MultipleResolveListener }
        预处理监听器(事件: "多路解析", 监听器: 多解析监听器_): 本体;

        //@@{ 预处理一次监听器:prependOnceListener, "在退出之前":"beforeExit", 之前退出监听器_:BeforeExitListener }
        预处理一次监听器(事件: "在退出之前", 监听器: 之前退出监听器_): 本体;

        //@@{ 预处理一次监听器:prependOnceListener, "断开连接":"disconnect", 断开连接监听器_:DisconnectListener }
        预处理一次监听器(事件: "断开连接", 监听器: 断开连接监听器_): 本体;

        //@@{ 预处理一次监听器:prependOnceListener, "退出":"exit", 退出监听器_:ExitListener }
        预处理一次监听器(事件: "退出", 监听器: 退出监听器_): 本体;

        //@@{ 预处理一次监听器:prependOnceListener, "拒绝处理":"rejectionHandled", 拒绝处理监听器_:RejectionHandledListener }
        预处理一次监听器(事件: "拒绝处理", 监听器: 拒绝处理监听器_): 本体;

        //@@{ 预处理一次监听器:prependOnceListener, "未捕获异常":"uncaughtException", 异常监听器_:UncaughtExceptionListener }
        预处理一次监听器(事件: "未捕获异常", 监听器: 异常监听器_): 本体;

        //@@{ 预处理一次监听器:prependOnceListener, "未处理的拒绝":"unhandledRejection", 未处理的拒绝监听器_:UnhandledRejectionListener }
        预处理一次监听器(事件: "未处理的拒绝", 监听器: 未处理的拒绝监听器_): 本体;

        //@@{ 预处理一次监听器:prependOnceListener, "警告":"warning", 警告监听器_:WarningListener }
        预处理一次监听器(事件: "警告", 监听器: 警告监听器_): 本体;

        //@@{ 预处理一次监听器:prependOnceListener, "消息":"message", 消息监听器_:MessageListener }
        预处理一次监听器(事件: "消息", 监听器: 消息监听器_): 本体;

        //@@{ 预处理一次监听器:prependOnceListener, 信号_:Signals, 信号监听器_:SignalsListener }
        预处理一次监听器(事件: 信号_, 监听器: 信号监听器_): 本体;

        //@@{ 预处理一次监听器:prependOnceListener, "新监听器":"newListener", 新监听器监听器_:NewListenerListener }
        预处理一次监听器(事件: "新监听器", 监听器: 新监听器监听器_): 本体;

        //@@{ 预处理一次监听器:prependOnceListener, "移除监听器":"removeListener", 删除监听器监听器_:RemoveListenerListener }
        预处理一次监听器(事件: "移除监听器", 监听器: 删除监听器监听器_): 本体;

        //@@{ 预处理一次监听器:prependOnceListener, "多路解析":"multipleResolves", 多解析监听器_:MultipleResolveListener }
        预处理一次监听器(事件: "多路解析", 监听器: 多解析监听器_): 本体;

        //@@{ 监听者:listeners, "在退出之前":"beforeExit", 之前退出监听器_:BeforeExitListener }
        监听者(事件: "在退出之前"): 之前退出监听器_[];

        //@@{ 监听者:listeners, "断开连接":"disconnect", 断开连接监听器_:DisconnectListener }
        监听者(事件: "断开连接"): 断开连接监听器_[];

        //@@{ 监听者:listeners, "退出":"exit", 退出监听器_:ExitListener }
        监听者(事件: "退出"): 退出监听器_[];

        //@@{ 监听者:listeners, "拒绝处理":"rejectionHandled", 拒绝处理监听器_:RejectionHandledListener }
        监听者(事件: "拒绝处理"): 拒绝处理监听器_[];

        //@@{ 监听者:listeners, "未捕获异常":"uncaughtException", 异常监听器_:UncaughtExceptionListener }
        监听者(事件: "未捕获异常"): 异常监听器_[];

        //@@{ 监听者:listeners, "未处理的拒绝":"unhandledRejection", 未处理的拒绝监听器_:UnhandledRejectionListener }
        监听者(事件: "未处理的拒绝"): 未处理的拒绝监听器_[];

        //@@{ 监听者:listeners, "警告":"warning", 警告监听器_:WarningListener }
        监听者(事件: "警告"): 警告监听器_[];

        //@@{ 监听者:listeners, "消息":"message", 消息监听器_:MessageListener }
        监听者(事件: "消息"): 消息监听器_[];

        //@@{ 监听者:listeners, 信号_:Signals, 信号监听器_:SignalsListener }
        监听者(事件: 信号_): 信号监听器_[];

        //@@{ 监听者:listeners, "新监听器":"newListener", 新监听器监听器_:NewListenerListener }
        监听者(事件: "新监听器"): 新监听器监听器_[];

        //@@{ 监听者:listeners, "移除监听器":"removeListener", 删除监听器监听器_:RemoveListenerListener }
        监听者(事件: "移除监听器"): 删除监听器监听器_[];

        //@@{ 监听者:listeners, "多路解析":"multipleResolves", 多解析监听器_:MultipleResolveListener }
        监听者(事件: "多路解析"): 多解析监听器_[];
    }

    //@@{ 全局_:Global }
    接口 全局_ {

        //@@{ 数组_:Array }
        数组_: 类为 数组_;

        //@@{ 数组缓冲区_:ArrayBuffer }
        数组缓冲区_: 类为 数组缓冲区_;

        //@@{ 真假_:Boolean }
        真假_: 类为 真假_;

        //@@{ 缓冲区_:Buffer }
        缓冲区_: 类为 缓冲区_;

        //@@{ 数据视图_:DataView }
        数据视图_: 类为 数据视图_;

        //@@{ 日期_:Date }
        日期_: 类为 日期_;

        //@@{ 错误_:Error }
        错误_: 类为 错误_;

        //@@{ 执行错误_:EvalError }
        执行错误_: 类为 执行错误_;

        //@@{ 浮点数组32_:Float32Array }
        浮点数组32_: 类为 浮点数组32_;

        //@@{ 浮点数组64_:Float64Array }
        浮点数组64_: 类为 浮点数组64_;

        //@@{ 函数_:Function }
        函数_: 类为 函数_;

        //@@{ __全局__:GLOBAL, 全局_:Global }
        __全局__: 全局_;

        //@@{ 无穷大_:Infinity }
        无穷大_: 类为 无穷大_;

        //@@{ 整数数组16_:Int16Array }
        整数数组16_: 类为 整数数组16_;

        //@@{ 整数数组32_:Int32Array }
        整数数组32_: 类为 整数数组32_;

        //@@{ 整数数组8_:Int8Array }
        整数数组8_: 类为 整数数组8_;

        //@@{ 国际化_:Intl }
        国际化_: 类为 国际化_;
        JSON: 类为 JSON;

        //@@{ 映射_:Map, 映射构造函数_:MapConstructor }
        映射_: 映射构造函数_;

        //@@{ 数学_:Math }
        数学_: 类为 数学_;

        //@@{ 非数字_:NaN }
        非数字_: 类为 非数字_;

        //@@{ 数字_:Number }
        数字_: 类为 数字_;

        //@@{ 实例_:Object }
        实例_: 类为 实例_;

        //@@{ 预设_:Promise, 函数_:Function }
        预设_: 函数_;

        //@@{ 范围错误_:RangeError }
        范围错误_: 类为 范围错误_;

        //@@{ 引用错误_:ReferenceError }
        引用错误_: 类为 引用错误_;

        //@@{ 正则_:RegExp }
        正则_: 类为 正则_;

        //@@{ 集合_:Set, 集合构造函数_:SetConstructor }
        集合_: 集合构造函数_;

        //@@{ 文字_:String }
        文字_: 类为 文字_;

        //@@{ 符号_:Symbol, 函数_:Function }
        符号_: 函数_;

        //@@{ 语法错误_:SyntaxError }
        语法错误_: 类为 语法错误_;

        //@@{ 类型错误_:TypeError }
        类型错误_: 类为 类型错误_;

        //@@{ URI错误_:URIError }
        URI错误_: 类为 URI错误_;

        //@@{ 正整数数组16_:Uint16Array }
        正整数数组16_: 类为 正整数数组16_;

        //@@{ 正整数数组32_:Uint32Array }
        正整数数组32_: 类为 正整数数组32_;

        //@@{ 正整数数组8_:Uint8Array }
        正整数数组8_: 类为 正整数数组8_;

        //@@{ 正整数固定数组8_:Uint8ClampedArray, 函数_:Function }
        正整数固定数组8_: 函数_;

        //@@{ 弱映射_:WeakMap, 弱映射构造函数_:WeakMapConstructor }
        弱映射_: 弱映射构造函数_;

        //@@{ 弱集合_:WeakSet, 弱集合构造函数_:WeakSetConstructor }
        弱集合_: 弱集合构造函数_;

        //@@{ 清除立即:clearImmediate, 立即_:Immediate }
        清除立即: (立即Id: 立即_) => 无值;

        //@@{ 清除时间间隔:clearInterval, 超时_:Timeout }
        清除时间间隔: (间隔Id: 超时_) => 无值;

        //@@{ 清除超时:clearTimeout, 超时_:Timeout }
        清除超时: (超时Id: 超时_) => 无值;

        //@@{ 控制台:console }
        控制台: 类为 控制台;

        //@@{ 解码URI:decodeURI }
        解码URI: 类为 解码URI;

        //@@{ 解码URI组件:decodeURIComponent }
        解码URI组件: 类为 解码URI组件;

        //@@{ 编码URI:encodeURI }
        编码URI: 类为 编码URI;

        //@@{ 编码URI组件:encodeURIComponent }
        编码URI组件: 类为 编码URI组件;

        //@@{ 转义:escape }
        转义: (字符串: 文字) => 文字;

        //@@{ 执行:eval }
        执行: 类为 执行;

        //@@{ 全局:global, 全局_:Global }
        全局: 全局_;

        //@@{ 是有限的:isFinite }
        是有限的: 类为 是有限的;

        //@@{ 是非数字:isNaN }
        是非数字: 类为 是非数字;

        //@@{ 编译浮点:parseFloat }
        编译浮点: 类为 编译浮点;

        //@@{ 编译整数:parseInt }
        编译整数: 类为 编译整数;

        //@@{ 进程:process, 进程_:Process }
        进程: 进程_;

        //@@{ 根:root, 全局_:Global }
        根: 全局_;

        //@@{ 设置立即:setImmediate, 立即_:Immediate }
        设置立即: (回调: (...参数组: 任意[]) => 无值, ...参数组: 任意[]) => 立即_;

        //@@{ 设置时间间隔:setInterval, 超时_:Timeout }
        设置时间间隔: (回调: (...参数组: 任意[]) => 无值, 毫秒: 数字, ...参数组: 任意[]) => 超时_;

        //@@{ 设置超时:setTimeout, 超时_:Timeout }
        设置超时: (回调: (...参数组: 任意[]) => 无值, 毫秒: 数字, ...参数组: 任意[]) => 超时_;

        //@@{ 队列微任务:queueMicrotask }
        队列微任务: 类为 队列微任务;

        //@@{ 未定:undefined }
        未定: 类为 未定;

        //@@{ 反转义:unescape }
        反转义: (字符串: 文字) => 文字;

        //@@{ 垃圾回收:gc }
        垃圾回收: () => 无值;

        //@@{ v8调试:v8debug }
        v8调试?: 任意;
    }

    //@@{ 计时器_:Timer }
    接口 计时器_ {

        //@@{ 限制退出:ref }
        限制退出(): 无值;

        //@@{ 刷新:refresh }
        刷新(): 无值;

        //@@{ 解除限制:unref }
        解除限制(): 无值;
    }

    //@@{ 立即_:Immediate }
    类别 立即_ {

        //@@{ 限制退出:ref }
        限制退出(): 无值;

        //@@{ 解除限制:unref }
        解除限制(): 无值;

        //@@{ _正在立即:_onImmediate, 函数_:Function }
        _正在立即: 函数_; // to distinguish it from the Timeout class
    }

    //@@{ 超时_:Timeout, 计时器_:Timer }
    类别 超时_ 实现 计时器_ {

        //@@{ 限制退出:ref }
        限制退出(): 无值;

        //@@{ 刷新:refresh }
        刷新(): 无值;

        //@@{ 解除限制:unref }
        解除限制(): 无值;
    }

    //@@{ 模块_:Module }
    类别 模块_ {

        //@@{ 运行主模块:runMain }
        静态 运行主模块(): 无值;

        //@@{ 包装:wrap }
        静态 包装(代码: 文字): 文字;

        //@@{ 创建需求从路径:createRequireFromPath }
        静态 创建需求从路径(路径: 文字): (路径: 文字) => 任意;

        //@@{ 内置模块:builtinModules }
        静态 内置模块: 文字[];

        //@@{ 模块_:Module }
        静态 模块_: 类为 模块_;

        //@@{ 输出组:exports }
        输出组: 任意;

        //@@{ 需要:require, Node需要函数_:NodeRequireFunction }
        需要: Node需要函数_;
        id: 文字;

        //@@{ 文件名称:filename }
        文件名称: 文字;

        //@@{ 加载了:loaded }
        加载了: 真假;

        //@@{ 父:parent, 模块_:Module }
        父: 模块_ | 空值;

        //@@{ 子属性:children, 模块_:Module }
        子属性: 模块_[];

        //@@{ 路径组:paths }
        路径组: 文字[];

        //@@{ 模块_:Module }
        构造(id: 文字, 父?: 模块_);
    }

    //@@{ 类型数组_:TypedArray, 正整数数组8_:Uint8Array, 正整数固定数组8_:Uint8ClampedArray }
    //@@{ 正整数数组16_:Uint16Array, 正整数数组32_:Uint32Array, 整数数组8_:Int8Array, 整数数组16_:Int16Array }
    //@@{ 整数数组32_:Int32Array, 浮点数组32_:Float32Array, 浮点数组64_:Float64Array }
    类型 类型数组_ = 正整数数组8_ | 正整数固定数组8_ | 正整数数组16_ | 正整数数组32_ | 整数数组8_ | 整数数组16_ | 整数数组32_ | 浮点数组32_ | 浮点数组64_;
}
